Please address the comments from this code review:

## Overall Comments
- The relative-path computation for symlinks in `reset` does manual `std::string` prefix checks with `'/'`, which will break on Windows-style `\` separators; consider normalizing separators or using `fs::relative` where possible to avoid platform-specific bugs.
- Storing the symlink target as `fs::read_symlink(path).string()` and writing that verbatim into the ZIP may embed platform-specific path formats; consider normalizing to a consistent ZIP-style path (e.g., forward slashes) or storing it as `fs::path` and converting via `utils::toZipPath` when writing.
- When setting `externalAttr` for symlinks you currently hardcode `0120777` permissions; if you care about preserving original permission bits, you may want to derive the mode from `status.permissions()` and OR it with `S_IFLNK` instead of using a fixed value.

## Individual Comments

### Comment 1
<location> `3rdparty/pzip/src/file_task.cpp:122-128` </location>
<code_context>
-        if (ec) {
-            // 如果无法计算相对路径，使用文件名
-            header.name = path.filename().string();
+        std::string pathStr = path.string();
+        std::string relToStr = relativeTo.string();
+        if (!relToStr.empty() && relToStr.back() != '/') {
+            relToStr += '/';
+        }
+        
+        if (pathStr.find(relToStr) == 0) {
+            // path 以 relativeTo 开头，直接截取
+            header.name = utils::toZipPath(pathStr.substr(relToStr.size()));
</code_context>

<issue_to_address>
**suggestion (bug_risk):** String-prefix check for relative path can misbehave on edge cases and is platform-sensitive.

`pathStr.find(relToStr) == 0` can match unintended prefixes (e.g., `/foo` vs `/foobar`) and breaks when separators differ (`/` vs `\` on Windows). To avoid `fs::relative` while still handling symlinks carefully, consider normalizing both paths (including separators and ensuring a path-boundary after `relToStr`) or using `fs::path` APIs up to the point of constructing the final relative string, so the prefix check is based on canonicalized components rather than raw strings.

Suggested implementation:

```cpp
    // 设置相对路径名
    // 注意：fs::relative() 会解析符号链接，这里使用路径组件比较避免解析符号链接
    if (!relativeTo.empty()) {
        // 使用 path 组件而不是字符串前缀，避免 /foo 与 /foobar 等前缀问题，
        // 同时不依赖平台分隔符
        auto relBegin = relativeTo.begin();
        auto relEnd   = relativeTo.end();
        auto pathBegin = path.begin();
        auto pathEnd   = path.end();

        // relativeTo 的组件数不能多于 path
        if (std::distance(relBegin, relEnd) <= std::distance(pathBegin, pathEnd) &&
            std::equal(relBegin, relEnd, pathBegin)) {
            // 构造相对路径：path 去掉 relativeTo 前缀后的部分
            fs::path relPath;
            auto it = pathBegin;
            std::advance(it, std::distance(relBegin, relEnd));
            for (; it != pathEnd; ++it) {
                relPath /= *it;
            }

            // 如果恰好相等，则仍然退回到使用文件名，以避免空名
            if (!relPath.empty()) {
                header.name = utils::toZipPath(relPath);
            } else {
                header.name = utils::toZipPath(path.filename());
            }
        } else {
            // 回退到使用文件名
            header.name = utils::toZipPath(path.filename());
        }
    } else {
        header.name = utils::toZipPath(path.filename());

```

If this file does not already include `<algorithm>` and `<iterator>`, you should add them at the top of `3rdparty/pzip/src/file_task.cpp` so that `std::equal` and `std::distance` are available:

- `#include <algorithm>`
- `#include <iterator>`
</issue_to_address>

### Comment 2
<location> `3rdparty/pzip/src/file_task.cpp:85` </location>
<code_context>

     bufferUsed_ = 0;
     written_ = 0;
+    isSymlink = false;
+    symlinkTarget.clear();

</code_context>

<issue_to_address>
**issue (complexity):** Consider replacing the custom relative-path logic with a helper using `lexically_relative` and extracting symlink/file-type handling into a dedicated helper to simplify `reset`.

The manual relative-path handling and the extra branching in `reset` do increase complexity; you can simplify without changing behavior.

### 1. Replace manual string-based relative path with `lexically_relative`

You can avoid mixing `std::filesystem::path` with ad‑hoc string manipulation and avoid `fs::relative()` (which resolves symlinks) by using `lexically_relative` and a small helper:

```cpp
// helper (e.g. in an anonymous namespace or a util header)
fs::path makeZipRelativePath(const fs::path& path, const fs::path& base) {
    fs::path rel = path.lexically_relative(base);
    // If not under base, fall back to filename (current behavior)
    if (rel.empty() || rel.native().rfind("..", 0) == 0 || rel.is_absolute()) {
        return path.filename();
    }
    return rel;
}
```

Usage in `reset`:

```cpp
// 设置相对路径名
if (!relativeTo.empty()) {
    fs::path relPath = makeZipRelativePath(path, relativeTo);
    header.name = utils::toZipPath(relPath);
} else {
    header.name = utils::toZipPath(path.filename());
}
```

This keeps symlinks un-resolved (purely lexical arithmetic), removes assumptions about `/`, and avoids repeated `string()` calls.

### 2. Extract symlink handling out of `reset`

`reset` is doing many things now (state reset, status detection, symlink handling, size determination, relative path). You can factor out the symlink/file-type logic into a small helper to reduce branching and make `reset` easier to scan:

```cpp
// helper
Error initFileTypeAndSize(const fs::path& path,
                          fs::file_status& status,
                          bool& isSymlink,
                          std::string& symlinkTarget,
                          uint64_t& fileSize) {
    std::error_code ec;
    status = fs::symlink_status(path, ec);
    if (ec) {
        return Error(ErrorCode::FILE_NOT_FOUND, "Cannot stat file: " + path.string());
    }

    isSymlink = fs::is_symlink(status);
    if (isSymlink) {
        symlinkTarget = fs::read_symlink(path, ec).string();
        if (ec) {
            return Error(ErrorCode::FILE_READ_ERROR, "Cannot read symlink target: " + path.string());
        }
        fileSize = symlinkTarget.size();
    } else if (fs::is_regular_file(status)) {
        fileSize = fs::file_size(path, ec);
        if (ec) {
            return Error(ErrorCode::FILE_READ_ERROR, "Cannot get file size: " + path.string());
        }
    } else {
        fileSize = 0;
    }
    return Error::success();
}
```

Then in `reset`:

```cpp
isSymlink = false;
symlinkTarget.clear();
path = filePath;

Error err = initFileTypeAndSize(path, status, isSymlink, symlinkTarget, fileSize);
if (!err.ok()) {
    return err;
}
```

This preserves all new functionality (symlink size and target handling) but reduces complexity and concentrates path and symlink logic in focused helpers.
</issue_to_address>